home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
ftp.mactech.com 2010
/
ftp.mactech.com.tar
/
ftp.mactech.com
/
thinkref
/
archive
/
THINKPascalUH2.1.sea
/
THINKPas Univ Hdr 2.1
/
Interfaces
/
OCEMail.p
< prev
next >
Wrap
Text File
|
1995-09-14
|
45KB
|
1,642 lines
{ Converted with MPW2TPas Tuesday, September 12, 1995 8:29:56 PM }
{}
{ File: OCEMail.p}
{ }
{ Contains: Apple Open Collaboration Environment OCEMail Interfaces.}
{ }
{ Version: Technology: AOCE Toolbox 1.02}
{ Package: Universal Interfaces 2.1 in “MPW Latest” on ETO #18}
{ }
{ Copyright: © 1984-1995 by Apple Computer, Inc.}
{ All rights reserved.}
{ }
{ Bugs?: If you find a problem with this file, use the Apple Bug Reporter}
{ stack. Include the file and version information (from above)}
{ in the problem description and send to:}
{ Internet: apple.bugs@applelink.apple.com}
{ AppleLink: APPLE.BUGS}
{ }
{}
unit OCEMail;
interface
{$IFC UNDEFINED __OCEMAIL__}
{$SETC __OCEMAIL__ := 1}
uses
ConditionalMacros, Types, AppleTalk, Processes, PPCToolbox, Notification, EPPC, Files, Aliases, AppleEvents, Memory, TextEdit, DigitalSignature, OCE, OCEAuthDir, OCEMessaging;
{ $PUSH}
{ $ALIGN MAC68K}
{ $LibExport+}
type
MSAMIOCompletionProcPtr = ProcPtr; { PROCEDURE MSAMIOCompletion(VAR paramBlock: MSAMParam); }
MSAMIOCompletionUPP = UniversalProcPtr;
MailMsgRef = LONGINT;
{ reference to an open msam queue }
MSAMQueueRef = LONGINT;
{ identifies slots managed by a PMSAM }
MSAMSlotID = INTEGER;
{ reference to an active mailbox }
MailboxRef = LONGINT;
{ identifies slots within a mailbox }
MailSlotID = INTEGER;
{ identifies a letter in a mailbox }
MailSeqNum = record
slotID: MailSlotID;
seqNum: LONGINT;
end;
{ A MailBuffer is used to describe a buffer used for an IO operation.}
{The location of the buffer is pointed to by 'buffer'. }
{When reading, the size of the buffer is 'bufferSize' }
{and the size of data actually read is 'dataSize'.}
{When writing, the size of data to be written is 'bufferSize' }
{and the size of data actually written is 'dataSize'.}
{}
MailBuffer = record
bufferSize: LONGINT;
buffer: Ptr;
dataSize: LONGINT;
end;
{ A MailReply is used to describe a commonly used reply buffer format.}
{It contains a count of tuples followed by an array of tuples.}
{The format of the tuple itself depends on each particular call.}
{}
MailReply = record
tupleCount: INTEGER;
{ tuple[tupleCount] }
end;
{ Shared Memory Communication Area used when Mail Manager sends }
{High Level Events to a PMSAM. }
{}
SMCA = record
smcaLength: INTEGER; { includes size of smcaLength field }
result: OSErr;
userBytes: LONGINT;
case INTEGER of
0: (
slotCID: CreationID; { for create/modify/delete slot calls }
);
1: (
msgHint: LONGINT; { for kMailEPPCMsgOpened }
);
end;
{************************************************************************************}
{ Value of creator and types fields for messages and blocks defined by MailManager }
const
kMailAppleMailCreator = 'apml'; { message and letter block creator }
kMailLtrMsgType = 'lttr'; { message type of letters, reports }
kMailLtrHdrType = 'lthd'; { contains letter header }
kMailContentType = 'body'; { contains content of letter }
kMailEnclosureListType = 'elst'; { contains list of enclosures }
kMailEnclosureDesktopType = 'edsk'; { contains desktop mgr info for enclosures }
kMailEnclosureFileType = 'asgl'; { contains a file enclosure }
{ format is defined by AppleSingle }
kMailImageBodyType = 'imag'; { contains image of letter }
{ format is struct TPfPgDir - in Printing.h}
{ * struct TPfPgDir (}
{ * short pageCount; - number of pages in the image.}
{ * long iPgPos[129]; - iPgPos[n] is the offset from the start of the block}
{ * - to image of page n.}
{ * - iPgPos[n+1] - iPgPos[n] is the length of page n.}
{}
kMailMSAMType = 'gwyi'; { contains msam specific information }
kMailTunnelLtrType = 'tunl'; { used to read a tunnelled message }
kMailHopInfoType = 'hopi'; { used to read hopInfo for a tunnelled message }
kMailReportType = 'rpti'; { contains report info }
{}
{Reports have the isReport bit set in MailIndications and contain a block of type kMailReport.}
{This block has a header, IPMReportBlockHeader,}
{followed by an array of elements, each of type IPMRecipientReport}
{}
{Various families used by mail or related msgs}
{}
kMailFamily = 'mail'; { Defines family of "mail" msgs: content, header, etc }
kMailFamilyFile = 'file';
{************************************************************************************}
type
MailAttributeID = INTEGER;
{ Values of MailAttributeID }
{ Message store attributes - stored in the catalog }
{ Will always be present in a letter and have fixed sizes }
const
kMailLetterFlagsBit = 1; { MailLetterFlags }
{ Letter attributes - stored in the letter }
{ Will always be present in a letter and have fixed sizes }
kMailIndicationsBit = 3; { MailIndications }
kMailMsgTypeBit = 4; { OCECreatorType }
kMailLetterIDBit = 5; { MailLetterID }
kMailSendTimeStampBit = 6; { MailTime }
kMailNestingLevelBit = 7; { MailNestingLevel }
kMailMsgFamilyBit = 8; { OSType }
{ Letter attributes - stored in the letter}
{ May be present in a letter and have fixed sizes }
kMailReplyIDBit = 9; { MailLetterID }
kMailConversationIDBit = 10; { MailLetterID }
{ Letter attributes - stored in the letter}
{ May be present in a letter and have variable length sizes }
kMailSubjectBit = 11; { RString }
kMailFromBit = 12; { MailRecipient }
kMailToBit = 13; { MailRecipient }
kMailCcBit = 14; { MailRecipient }
kMailBccBit = 15; { MailRecipient }
type
MailAttributeMask = LONGINT;
{ Values of MailAttributeMask }
const
kMailLetterFlagsMask = $1;
kMailIndicationsMask = $4;
kMailMsgTypeMask = $8;
kMailLetterIDMask = $10;
kMailSendTimeStampMask = $20;
kMailNestingLevelMask = $40;
kMailMsgFamilyMask = $80;
kMailReplyIDMask = $100;
kMailConversationIDMask = $200;
kMailSubjectMask = $400;
kMailFromMask = $800;
kMailToMask = $1000;
kMailCcMask = $2000;
kMailBccMask = $4000;
type
MailAttributeBitmap = LONGINT;
{************************************************************************************}
MailLetterSystemFlags = INTEGER;
{ Values of MailLetterSystemFlags }
{ letter is available locally (either by nature or via cache) }
const
kMailIsLocalBit = 2;
kMailIsLocalMask = $4;
type
MailLetterUserFlags = INTEGER;
const
kMailReadBit = 0; { this letter has been opened }
kMailDontArchiveBit = 1; { this letter is not }
{ to be archived either because }
{ it has already been archived or }
{ it should not be archived. }
kMailInTrashBit = 2; { this letter is in trash }
{ Values of MailLetterUserFlags }
kMailReadMask = $1;
kMailDontArchiveMask = $2;
kMailInTrashMask = $4;
type
MailLetterFlags = record
sysFlags: MailLetterSystemFlags;
userFlags: MailLetterUserFlags;
end;
MailMaskedLetterFlags = record
flagMask: MailLetterFlags; { flags that are to be set }
flagValues: MailLetterFlags; { and their values }
end;
const
kMailOriginalInReportBit = 1;
kMailNonReceiptReportsBit = 3;
kMailReceiptReportsBit = 4;
kMailForwardedBit = 5;
kMailPriorityBit = 6;
kMailIsReportWithOriginalBit = 8;
kMailIsReportBit = 9;
kMailHasContentBit = 10;
kMailHasSignatureBit = 11;
kMailAuthenticatedBit = 12;
kMailSentBit = 13;
kMailNativeContentBit = 14;
kMailImageContentBit = 15;
kMailStandardContentBit = 16;
{ Values of MailIndications }
kMailStandardContentMask = $8000;
kMailImageContentMask = $4000;
kMailNativeContentMask = $2000;
kMailSentMask = $1000;
kMailAuthenticatedMask = $800;
kMailHasSignatureMask = $400;
kMailHasContentMask = $200;
kMailIsReportMask = $100;
kMailIsReportWithOriginalMask = $80;
kMailPriorityMask = $60;
kMailForwardedMask = $10;
kMailReceiptReportsMask = $8;
kMailNonReceiptReportsMask = $4;
kMailOriginalInReportMask = $3;
type
MailIndications = LONGINT;
{ values of the field originalInReport in MailIndications }
const
kMailNoOriginal = 0; { do not enclose original in reports }
kMailEncloseOnNonReceipt = 3; { enclose original in non-delivery reports }
type
MailLetterID = IPMMsgID;
MailTime = record
time: UTCTime; { current UTC(GMT) time }
offset: UTCOffset; { offset from GMT }
end;
{ innermost letter has nestingLevel 0 }
MailNestingLevel = INTEGER;
MailRecipient = OCERecipient;
{************************************************************************************}
const
kMailTextSegmentBit = 0;
kMailPictSegmentBit = 1;
kMailSoundSegmentBit = 2;
kMailStyledTextSegmentBit = 3;
kMailMovieSegmentBit = 4;
type
MailSegmentMask = INTEGER;
{ Values of MailSegmentMask }
const
kMailTextSegmentMask = $1;
kMailPictSegmentMask = $2;
kMailSoundSegmentMask = $4;
kMailStyledTextSegmentMask = $8;
kMailMovieSegmentMask = $10;
type
MailSegmentType = INTEGER;
{ Values of MailSegmentType }
const
kMailInvalidSegmentType = 0;
kMailTextSegmentType = 1;
kMailPictSegmentType = 2;
kMailSoundSegmentType = 3;
kMailStyledTextSegmentType = 4;
kMailMovieSegmentType = 5;
{************************************************************************************}
kMailErrorLogEntryVersion = $101;
kMailMSAMErrorStringListID = 128; { These 'STR#' resources should be }
kMailMSAMActionStringListID = 129; { in the PMSAM resource fork }
type
MailLogErrorType = INTEGER;
{ Values of MailLogErrorType }
const
kMailELECorrectable = 0;
kMailELEError = 1;
kMailELEWarning = 2;
kMailELEInformational = 3;
type
MailLogErrorCode = INTEGER;
{ Values of MailLogErrorCode }
const
kMailMSAMErrorCode = 0; { positive codes are indices into}
{ PMSAM defined strings }
kMailMiscError = -1; { negative codes are OCE defined }
kMailNoModem = -2; { modem required, but missing }
type
MailErrorLogEntryInfo = record
version: INTEGER;
timeOccurred: UTCTime; { do not fill in }
reportingPMSAM: Str31; { do not fill in }
reportingMSAMSlot: Str31; { do not fill in }
errorType: MailLogErrorType;
errorCode: MailLogErrorCode;
errorResource: INTEGER; { resources are valid if }
actionResource: INTEGER; { errorCode = kMailMSAMErrorCode}
{ index starts from 1 }
filler: LONGINT;
filler2: INTEGER;
end;
{************************************************************************************}
MailBlockMode = INTEGER;
{ Values of MailBlockMode }
const
kMailFromStart = 1; { write data from offset calculated from }
kMailFromLEOB = 2; { start of block, end of block, }
kMailFromMark = 3; { or from the current mark }
type
MailEnclosureInfo = record
enclosureName: StringPtr;
catInfo: CInfoPBPtr;
comment: StringPtr;
icon: Ptr;
end;
{************************************************************************************}
const
kOCESetupLocationNone = 0; { disconnect state }
kOCESetupLocationMax = 8; { maximum location value }
type
OCESetupLocation = CHAR;
{ location state is a bitmask, 0x1=>1st location active, }
{ * 0x2 => 2nd, 0x4 => 3rd, etc.}
{ }
MailLocationFlags = SInt8;
MailLocationInfo = record
location: OCESetupLocation;
active: MailLocationFlags;
end;
{************************************************************************************}
{ Definitions for Personal MSAMs }
{************************************************************************************}
const
kMailEPPCMsgVersion = 3;
type
MailEPPCMsg = record
version: INTEGER;
case INTEGER of
0: (
theSMCA: ^SMCA; { for 'crsl', 'mdsl', 'dlsl', 'sndi', 'msgo', 'admn' }
);
1: (
sequenceNumber: LONGINT; { for 'inqu', 'dlom' }
);
2: (
locationInfo: MailLocationInfo; { for 'locc' }
);
end;
{ Values of OCE defined High Level Event message classes }
const
kMailEPPCCreateSlot = 'crsl';
kMailEPPCModifySlot = 'mdsl';
kMailEPPCDeleteSlot = 'dlsl';
kMailEPPCShutDown = 'quit';
kMailEPPCMailboxOpened = 'mbop';
kMailEPPCMailboxClosed = 'mbcl';
kMailEPPCMsgPending = 'msgp';
kMailEPPCSendImmediate = 'sndi';
kMailEPPCContinue = 'cont';
kMailEPPCSchedule = 'sked';
kMailEPPCAdmin = 'admn';
kMailEPPCInQUpdate = 'inqu';
kMailEPPCMsgOpened = 'msgo';
kMailEPPCDeleteOutQMsg = 'dlom';
kMailEPPCWakeup = 'wkup';
kMailEPPCLocationChanged = 'locc';
type
MailTimer = record
case INTEGER of
0: (
frequency: LONGINT; { how often to connect }
);
1: (
connectTime: LONGINT; { time since midnight }
);
end;
const
kMailTimerOff = 0; { control is off }
kMailTimerTime = 1; { specifies connect time (relative to midnight) }
kMailTimerFrequency = 2; { specifies connect frequency }
type
MailTimerKind = SInt8;
MailTimers = record
sendTimeKind: MailTimerKind; { either kMailTimerTime or kMailTimerFrequency }
receiveTimeKind: MailTimerKind; { either kMailTimerTime or kMailTimerFrequency }
send: MailTimer;
receive: MailTimer;
end;
MailStandardSlotInfoAttribute = record
version: INTEGER;
active: MailLocationFlags; { active if MailLocationMask(i) is set }
padByte: SInt8; { Byte }
sendReceiveTimer: MailTimers;
end;
PMSAMGetMSAMRecordPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
msamCID: CreationID;
end;
PMSAMOpenQueuesPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
inQueueRef: MSAMQueueRef;
outQueueRef: MSAMQueueRef;
msamSlotID: MSAMSlotID;
filler: array[0..1] of LONGINT;
end;
PMSAMStatus = INTEGER;
{ Values of PMSAMStatus }
const
kPMSAMStatusPending = 1; { for inQueue and outQueue }
kPMSAMStatusError = 2; { for inQueue and outQueue }
kPMSAMStatusSending = 3; { for outQueue only }
kPMSAMStatusCaching = 4; { for inQueue only }
kPMSAMStatusSent = 5; { for outQueue only }
type
PMSAMSetStatusPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
queueRef: MSAMQueueRef;
seqNum: LONGINT;
msgHint: LONGINT; { for posting cache error,set this to 0 when report outq status }
status: PMSAMStatus;
end;
PMSAMLogErrorPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
msamSlotID: MSAMSlotID; { 0 for PMSAM errors }
logEntry: ^MailErrorLogEntryInfo;
filler: array[0..1] of LONGINT;
end;
{**************************************************************************************}
const
kMailMsgSummaryVersion = 1;
type
MailMasterData = record
attrMask: MailAttributeBitmap; { indicates attributes present in MsgSummary }
messageID: MailLetterID;
replyID: MailLetterID;
conversationID: MailLetterID;
end;
{ Values for addressedToMe in struct MailCoreData }
const
kAddressedAs_TO = $1;
kAddressedAs_CC = $2;
kAddressedAs_BCC = $4;
type
MailCoreData = record
letterFlags: MailLetterFlags;
messageSize: LONGINT;
letterIndications: MailIndications;
messageType: OCECreatorType;
sendTime: MailTime;
messageFamily: OSType;
reserved: SInt8; { unsigned char }
addressedToMe: SInt8; { unsigned char }
agentInfo: array[0..5] of CHAR; { 6 bytes of special info [set to zero]}
{ * these are variable length and even padded }
sender: RString32; { recipient's entityName (trunc)}
subject: RString32; { subject maybe truncated }
end;
MSAMMsgSummary = record
version: INTEGER; { following flags are defaulted by Toolbox }
msgDeleted: BOOLEAN; { true if msg is to be deleted by PMSAM }
msgUpdated: BOOLEAN; { true if msgSummary was updated by MailManager }
msgCached: BOOLEAN; { true if msg is in the slot's InQueue }
padByte: SInt8; { Byte }
masterData: MailMasterData;
coreData: MailCoreData;
end;
{ PMSAM can put up to 128 bytes of private msg summary data }
const
kMailMaxPMSAMMsgSummaryData = 128;
type
PMSAMCreateMsgSummaryPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
inQueueRef: MSAMQueueRef;
seqNum: LONGINT; { <- seq of the new message }
msgSummary: ^MSAMMsgSummary; { attributes and mask filled in }
buffer: ^MailBuffer; { PMSAM specific data to be appended }
end;
PMSAMPutMsgSummaryPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
inQueueRef: MSAMQueueRef;
seqNum: LONGINT;
letterFlags: ^MailMaskedLetterFlags; { if not nil, then set msgStoreFlags }
buffer: ^MailBuffer; { PMSAM specific data to be overwritten }
end;
PMSAMGetMsgSummaryPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
inQueueRef: MSAMQueueRef;
seqNum: LONGINT;
msgSummary: ^MSAMMsgSummary; { if not nil, then read in the msgSummary }
buffer: ^MailBuffer; { PMSAM specific data to be read }
msgSummaryOffset: INTEGER; { offset of PMSAM specific data}
{ from start of MsgSummary }
end;
{**************************************************************************************}
{ Definitions for Server MSAMs }
{************************************************************************************}
SMSAMAdminCode = INTEGER;
{ Values of SMSAMAdminCode }
const
kSMSAMNotifyFwdrSetupChange = 1;
kSMSAMNotifyFwdrNameChange = 2;
kSMSAMNotifyFwdrPwdChange = 3;
kSMSAMGetDynamicFwdrParams = 4;
type
SMSAMSlotChanges = LONGINT;
const
kSMSAMFwdrHomeInternetChangedBit = 0;
kSMSAMFwdrConnectedToChangedBit = 1;
kSMSAMFwdrForeignRLIsChangedBit = 2;
kSMSAMFwdrMnMServerChangedBit = 3;
{ Values of SMSAMSlotChanges }
kSMSAMFwdrEverythingChangedMask = -1;
kSMSAMFwdrHomeInternetChangedMask = $1;
kSMSAMFwdrConnectedToChangedMask = $2;
kSMSAMFwdrForeignRLIsChangedMask = $4;
kSMSAMFwdrMnMServerChangedMask = $8;
{ kSMSAMNotifyFwdrSetupChange }
type
SMSAMSetupChange = record
whatChanged: SMSAMSlotChanges; { --> bitmap of what parameters changed }
serverHint: AddrBlock; { --> try this ADAP server first }
end;
{ kSMSAMNotifyFwdrNameChange }
SMSAMNameChange = record
newName: RString; { --> msams new name }
serverHint: AddrBlock; { --> try this ADAP server first }
end;
{ kSMSAMNotifyFwdrPasswordChange }
SMSAMPasswordChange = record
newPassword: RString; { --> msams new password }
serverHint: AddrBlock; { --> try this ADAP server first }
end;
{ kSMSAMGetDynamicFwdrParams }
SMSAMDynamicParams = record
curDiskUsed: LONGINT; { <-- amount of disk space used by msam }
curMemoryUsed: LONGINT; { <-- amount of memory used by msam }
end;
SMSAMAdminEPPCRequest = record
adminCode: SMSAMAdminCode;
case INTEGER of
0: (
setupChange: SMSAMSetupChange;
);
1: (
nameChange: SMSAMNameChange;
);
2: (
passwordChange: SMSAMPasswordChange;
);
3: (
dynamicParams: SMSAMDynamicParams;
);
end;
SMSAMSetupPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
serverMSAM: RecordIDPtr;
password: RStringPtr;
gatewayType: OSType;
gatewayTypeDescription: RStringPtr;
catalogServerHint: AddrBlock;
end;
SMSAMStartupPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
msamIdentity: AuthIdentity;
queueRef: MSAMQueueRef;
end;
SMSAMShutdownPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
queueRef: MSAMQueueRef;
end;
{**************************************************************************************}
{ Definitions for reading and writing MSAM Letters }
{**************************************************************************************}
MSAMEnumeratePB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
queueRef: MSAMQueueRef;
startSeqNum: LONGINT;
nextSeqNum: LONGINT;
{ buffer contains a Mail Reply. Each tuple is a }
{ MSAMEnumerateInQReply when enumerating the inQueue}
{ MSAMEnumerateOutQReply when enumerating the outQueue }
buffer: MailBuffer;
end;
MSAMEnumerateInQReply = record
seqNum: LONGINT;
msgDeleted: BOOLEAN; { true if msg is to be deleted by PMSAM }
msgUpdated: BOOLEAN; { true if MsgSummary has been updated by TB }
msgCached: BOOLEAN; { true if msg is in the incoming queue }
padByte: SInt8; { Byte }
end;
MSAMEnumerateOutQReply = record
seqNum: LONGINT;
done: BOOLEAN; { true if all responsible recipients have been processed }
priority: IPMPriority;
msgFamily: OSType;
approxSize: LONGINT;
tunnelForm: BOOLEAN; { true if this letter has to be tunnelled }
padByte: SInt8; { Byte }
nextHop: NetworkSpec; { valid if tunnelForm is true }
msgType: OCECreatorType;
end;
MSAMDeletePB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
queueRef: MSAMQueueRef;
seqNum: LONGINT;
msgOnly: BOOLEAN; { only valid for PMSAM & inQueue }
{ set true to delete message but not msgSummary }
padByte: SInt8; { Byte }
{ only valid for SMSAM & tunnelled messages }
result: OSErr;
end;
MSAMOpenPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
queueRef: MSAMQueueRef;
seqNum: LONGINT;
mailMsgRef: MailMsgRef;
end;
MSAMOpenNestedPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
nestedRef: MailMsgRef;
end;
MSAMClosePB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
end;
MSAMGetMsgHeaderPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
selector: IPMHeaderSelector;
filler1: BOOLEAN;
offset: LONGINT;
buffer: MailBuffer;
remaining: LONGINT;
end;
MSAMGetAttributesPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
requestMask: MailAttributeBitmap; { kMailIndicationsBit thru kMailSubjectBit }
buffer: MailBuffer;
{ buffer returned will contain the attribute values of }
{ the attributes indicated in responseMask, }
{ from the attribute indicated by the least significant bit set}
{ to the attribute indicated by the most significant bit set.}
{ Note that recipients - from, to, cc, bcc cannot be read using}
{ this call. Use GetRecipients to read these. }
responseMask: MailAttributeBitmap;
more: BOOLEAN;
filler1: BOOLEAN;
end;
{ attrID value to get resolved recipient list }
const
kMailResolvedList = 0;
type
MailOriginalRecipient = record
index: INTEGER;
end;
{ Followed by OCEPackedRecipient }
MailResolvedRecipient = record
index: INTEGER;
recipientFlags: INTEGER;
responsible: BOOLEAN;
padByte: SInt8; { Byte }
end;
{ Followed by OCEPackedRecipient }
MSAMGetRecipientsPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
attrID: MailAttributeID; { kMailFromBit thru kMailBccBit }
startIndex: INTEGER; { starts at 1 }
buffer: MailBuffer;
{ buffer contains a Mail Reply. Each tuple is a}
{ MailOriginalRecipient if getting original recipients }
{ ie the attrID is kMail[From, To, Cc, Bcc]Bit}
{ MailResolvedRecipient if getting resolved reicpients}
{ ie the attrID is kMailResolvedList}
{ Both tuples are word alligned. }
nextIndex: INTEGER;
more: BOOLEAN;
filler1: BOOLEAN;
end;
MSAMGetContentPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
segmentMask: MailSegmentMask;
buffer: MailBuffer;
textScrap: ^StScrpRec;
script: ScriptCode;
segmentType: MailSegmentType;
endOfScript: BOOLEAN;
endOfSegment: BOOLEAN;
endOfContent: BOOLEAN;
filler1: BOOLEAN;
segmentLength: LONGINT; { NEW: <- valid first call in a segment }
segmentID: LONGINT; { NEW: <-> identifier for this segment }
end;
MSAMGetEnclosurePB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
contentEnclosure: BOOLEAN;
padByte: SInt8; { Byte }
buffer: MailBuffer;
endOfFile: BOOLEAN;
endOfEnclosures: BOOLEAN;
end;
MailBlockInfo = record
blockType: OCECreatorType;
offset: LONGINT;
blockLength: LONGINT;
end;
MSAMEnumerateBlocksPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
startIndex: INTEGER; { starts at 1 }
buffer: MailBuffer;
{ buffer contains a Mail Reply. Each tuple is a MailBlockInfo }
nextIndex: INTEGER;
more: BOOLEAN;
filler1: BOOLEAN;
end;
MSAMGetBlockPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
blockType: OCECreatorType;
blockIndex: INTEGER;
buffer: MailBuffer;
dataOffset: LONGINT;
endOfBlock: BOOLEAN;
padByte: SInt8; { Byte }
remaining: LONGINT;
end;
{ YOU SHOULD BE USING THE NEW FORM OF MARK RECIPIENTS}
{ * THIS VERSION IS MUCH SLOWER AND KEPT FOR COMPATIBILITY}
{ * REASONS.}
{}
{ not valid for tunnel form letters }
MSAMMarkRecipientsPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
queueRef: MSAMQueueRef;
seqNum: LONGINT;
{ buffer contains a Mail Reply. Each tuple is an unsigned short,}
{ the index of a recipient to be marked. }
buffer: MailBuffer;
end;
{ }
{ * same as MSAMMarkRecipients except it takes a mailMsgRef instead of }
{ * queueRef, seqNum }
{}
{ not valid for tunnel form letters }
MSAMnMarkRecipientsPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
{ buffer contains a Mail Reply. Each tuple is an unsigned short,}
{ the index of a recipient to be marked. }
buffer: MailBuffer;
end;
{**************************************************************************************}
MSAMCreatePB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
queueRef: MSAMQueueRef;
asLetter: BOOLEAN; { indicate if we should create as letter or msg }
filler1: BOOLEAN;
msgType: IPMMsgType; { up to application discretion: must be of IPMSenderTag}
{ kIPMOSFormatType for asLetter=true }
refCon: LONGINT; { for messages only }
seqNum: LONGINT; { set if creating message in the inQueue }
tunnelForm: BOOLEAN; { if true tunnelForm else newForm }
bccRecipients: BOOLEAN; { true if creating letter with bcc recipients }
newRef: MailMsgRef;
end;
MSAMBeginNestedPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
refCon: LONGINT; { for messages only }
msgType: IPMMsgType;
end;
MSAMEndNestedPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
end;
MSAMSubmitPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
submitFlag: BOOLEAN;
padByte: SInt8; { Byte }
msgID: MailLetterID;
end;
MSAMPutMsgHeaderPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
replyQueue: ^OCERecipient;
sender: ^IPMSender;
deliveryNotification: IPMNotificationType;
priority: IPMPriority;
end;
MSAMPutAttributePB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
attrID: MailAttributeID; { kMailIndicationsBit thru kMailSubjectBit }
buffer: MailBuffer;
end;
MSAMPutRecipientPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
attrID: MailAttributeID; { kMailFromBit thru kMailBccBit }
recipient: ^MailRecipient;
responsible: BOOLEAN; { valid for server and message msams only }
filler1: BOOLEAN;
end;
MSAMPutContentPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
segmentType: MailSegmentType;
append: BOOLEAN;
padByte: SInt8; { Byte }
buffer: MailBuffer;
textScrap: ^StScrpRec;
startNewScript: BOOLEAN;
filler1: BOOLEAN;
script: ScriptCode; { valid only if startNewScript is true }
end;
MSAMPutEnclosurePB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
contentEnclosure: BOOLEAN;
padByte: SInt8; { Byte }
hfs: BOOLEAN; { true => in file system, false => in memory }
append: BOOLEAN;
buffer: MailBuffer; { Unused if hfs == true }
enclosure: FSSpec;
addlInfo: MailEnclosureInfo;
end;
MSAMPutBlockPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
refCon: LONGINT; { for messages only }
blockType: OCECreatorType;
append: BOOLEAN;
filler1: BOOLEAN;
buffer: MailBuffer;
mode: MailBlockMode; { if blockType is kMailTunnelLtrType or kMailHopInfoType}
{ mode is assumed to be kMailFromMark }
offset: LONGINT;
end;
{**************************************************************************************}
MSAMCreateReportPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
queueRef: MSAMQueueRef; { to distinguish personal and server MSAMs }
mailMsgRef: MailMsgRef;
msgID: MailLetterID; { kMailLetterIDBit of letter being reported upon }
sender: ^MailRecipient; { sender of the letter you are creating report on }
end;
MSAMPutRecipientReportPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailMsgRef: MailMsgRef;
recipientIndex: INTEGER; { recipient index in the original letter }
result: OSErr; { result of sending the recipient }
end;
{**************************************************************************************}
MailWakeupPMSAMPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
pmsamCID: CreationID;
mailSlotID: MailSlotID;
end;
MailCreateMailSlotPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailboxRef: MailboxRef;
timeout: LONGINT;
pmsamCID: CreationID;
smca: SMCA;
end;
MailModifyMailSlotPB = record
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
mailboxRef: MailboxRef;
timeout: LONGINT;
pmsamCID: CreationID;
smca: SMCA;
end;
{**************************************************************************************}
MSAMParam = record
case INTEGER of
0: (
qLink: Ptr;
reservedH1: LONGINT;
reservedH2: LONGINT;
ioCompletion: MSAMIOCompletionUPP;
ioResult: OSErr;
saveA5: LONGINT;
reqCode: INTEGER;
);
1: (
pmsamGetMSAMRecord: PMSAMGetMSAMRecordPB;
);
2: (
pmsamOpenQueues: PMSAMOpenQueuesPB;
);
3: (
pmsamSetStatus: PMSAMSetStatusPB;
);
4: (
pmsamLogError: PMSAMLogErrorPB;
);
5: (
smsamSetup: SMSAMSetupPB;
);
6: (
smsamStartup: SMSAMStartupPB;
);
7: (
smsamShutdown: SMSAMShutdownPB;
);
8: (
msamEnumerate: MSAMEnumeratePB;
);
9: (
msamDelete: MSAMDeletePB;
);
10: (
msamOpen: MSAMOpenPB;
);
11: (
msamOpenNested: MSAMOpenNestedPB;
);
12: (
msamClose: MSAMClosePB;
);
13: (
msamGetMsgHeader: MSAMGetMsgHeaderPB;
);
14: (
msamGetAttributes: MSAMGetAttributesPB;
);
15: (
msamGetRecipients: MSAMGetRecipientsPB;
);
16: (
msamGetContent: MSAMGetContentPB;
);
17: (
msamGetEnclosure: MSAMGetEnclosurePB;
);
18: (
msamEnumerateBlocks: MSAMEnumerateBlocksPB;
);
19: (
msamGetBlock: MSAMGetBlockPB;
);
20: (
msamMarkRecipients: MSAMMarkRecipientsPB;
);
21: (
msamnMarkRecipients: MSAMnMarkRecipientsPB;
);
22: (
msamCreate: MSAMCreatePB;
);
23: (
msamBeginNested: MSAMBeginNestedPB;
);
24: (
msamEndNested: MSAMEndNestedPB;
);
25: (
msamSubmit: MSAMSubmitPB;
);
26: (
msamPutMsgHeader: MSAMPutMsgHeaderPB;
);
27: (
msamPutAttribute: MSAMPutAttributePB;
);
28: (
msamPutRecipient: MSAMPutRecipientPB;
);
29: (
msamPutContent: MSAMPutContentPB;
);
30: (
msamPutEnclosure: MSAMPutEnclosurePB;
);
31: (
msamPutBlock: MSAMPutBlockPB;
);
32: (
msamCreateReport: MSAMCreateReportPB; { Reports and Error Handling Calls }
);
33: (
msamPutRecipientReport: MSAMPutRecipientReportPB;
);
34: (
pmsamCreateMsgSummary: PMSAMCreateMsgSummaryPB;
);
35: (
pmsamPutMsgSummary: PMSAMPutMsgSummaryPB;
);
36: (
pmsamGetMsgSummary: PMSAMGetMsgSummaryPB;
);
37: (
wakeupPMSAM: MailWakeupPMSAMPB;
);
38: (
createMailSlot: MailCreateMailSlotPB;
);
39: (
modifyMailSlot: MailModifyMailSlotPB;
);
end;
const
uppMSAMIOCompletionProcInfo = $000000C0; { PROCEDURE (4 byte param); }
procedure CallMSAMIOCompletionProc (var paramBlock: MSAMParam; userRoutine: MSAMIOCompletionUPP);
{$IFC NOT GENERATINGCFM}
inline
$205F, $4E90;
{$ENDC}
function NewMSAMIOCompletionProc (userRoutine: MSAMIOCompletionProcPtr): MSAMIOCompletionUPP;
{$IFC NOT GENERATINGCFM }
inline
$2E9F;
{$ENDC}
function MailCreateMailSlot (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7001, $1f00, $3f3c, 1323, $AA5E;
{$ENDC}
{ ASYNCHRONOUS ONLY, client must call WaitNextEvent }
function MailModifyMailSlot (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7001, $1f00, $3f3c, 1324, $AA5E;
{$ENDC}
{ ASYNCHRONOUS ONLY, client must call WaitNextEvent }
function MailWakeupPMSAM (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7001, $1f00, $3f3c, 1287, $AA5E;
{$ENDC}
{ Personal MSAM Glue Routines }
function PMSAMOpenQueues (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7000, $1f00, $3f3c, 1280, $AA5E;
{$ENDC}
function PMSAMSetStatus (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1319, $AA5E;
{$ENDC}
{ SYNC ONLY }
function PMSAMGetMSAMRecord (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7000, $1f00, $3f3c, 1286, $AA5E;
{$ENDC}
{ Server MSAM Glue Routines }
{ SYNC ONLY }
function SMSAMSetup (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7000, $1f00, $3f3c, 1315, $AA5E;
{$ENDC}
{ SYNC ONLY }
function SMSAMStartup (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7000, $1f00, $3f3c, 1281, $AA5E;
{$ENDC}
function SMSAMShutdown (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1282, $AA5E;
{$ENDC}
{ Get Interface Glue Routines }
function MSAMEnumerate (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1283, $AA5E;
{$ENDC}
function MSAMDelete (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1284, $AA5E;
{$ENDC}
function MSAMMarkRecipients (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1285, $AA5E;
{$ENDC}
function MSAMnMarkRecipients (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1298, $AA5E;
{$ENDC}
function MSAMOpen (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1288, $AA5E;
{$ENDC}
function MSAMOpenNested (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1289, $AA5E;
{$ENDC}
function MSAMClose (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1290, $AA5E;
{$ENDC}
function MSAMGetRecipients (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1292, $AA5E;
{$ENDC}
function MSAMGetAttributes (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1291, $AA5E;
{$ENDC}
function MSAMGetContent (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1293, $AA5E;
{$ENDC}
function MSAMGetEnclosure (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1294, $AA5E;
{$ENDC}
function MSAMEnumerateBlocks (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1295, $AA5E;
{$ENDC}
function MSAMGetBlock (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1296, $AA5E;
{$ENDC}
function MSAMGetMsgHeader (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1297, $AA5E;
{$ENDC}
{ Put Interface Glue Routines }
function MSAMCreate (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1300, $AA5E;
{$ENDC}
function MSAMBeginNested (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1301, $AA5E;
{$ENDC}
function MSAMEndNested (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7000, $1f00, $3f3c, 1302, $AA5E;
{$ENDC}
{ SYNCHRONOUS ONLY }
function MSAMSubmit (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7000, $1f00, $3f3c, 1303, $AA5E;
{$ENDC}
function MSAMPutAttribute (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1304, $AA5E;
{$ENDC}
function MSAMPutRecipient (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1305, $AA5E;
{$ENDC}
function MSAMPutContent (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1306, $AA5E;
{$ENDC}
{ SYNCHRONOUS ONLY }
function MSAMPutEnclosure (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7000, $1f00, $3f3c, 1307, $AA5E;
{$ENDC}
function MSAMPutBlock (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1308, $AA5E;
{$ENDC}
function MSAMPutMsgHeader (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1309, $AA5E;
{$ENDC}
{ Reports and Error Handling Glue Routines }
function MSAMCreateReport (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1311, $AA5E;
{$ENDC}
function MSAMPutRecipientReport (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1312, $AA5E;
{$ENDC}
function PMSAMLogError (var paramBlock: MSAMParam): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$7000, $1f00, $3f3c, 1313, $AA5E;
{$ENDC}
{ MsgSummary Glue Routines }
function PMSAMCreateMsgSummary (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1314, $AA5E;
{$ENDC}
function PMSAMPutMsgSummary (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1317, $AA5E;
{$ENDC}
function PMSAMGetMsgSummary (var paramBlock: MSAMParam; asyncFlag: BOOLEAN): OSErr;
{$IFC NOT GENERATINGCFM}
inline
$3f3c, 1318, $AA5E;
{$ENDC}
{ $ALIGN RESET}
{ $POP}
{$ENDC}
{__OCEMAIL__}
implementation
end.